
import numpy as np
import pandas as pd
import datetime as dt
from matplotlib import pyplot as plt
import os
import plotly.express as px
import plotly.io as io


# load formatting extension, not necessary
%load_ext nb_black


# read aggregate data file
data = pd.read_csv("aggregate_data.csv")


# view aggregate data
data


# remove lines with calculations that have errors, which is marked in the energy column
# marked if no energy value is produced or if an error is found by inspecting raw data
data_valid = data[data.Energy != "error"]


# get time expressed in seconds
def get_seconds(row):
    time_str = row["Runtime"]
    baseline = "00:00:00"
    read_time = dt.datetime.strptime(time_str, "%H:%M:%S")
    read_baseline = dt.datetime.strptime(baseline, "%H:%M:%S")
    total_time = read_time - read_baseline
    seconds = total_time.total_seconds()
    return seconds


data_valid["Runtime(s)"] = data_valid.apply(get_seconds, axis=1)

<ipython-input-1-463a550ca1a3>:12: SettingWithCopyWarning: 
A value is trying to be set on a copy of a slice from a DataFrame.
Try using .loc[row_indexer,col_indexer] = value instead

See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy
  data_valid["Runtime(s)"] = data_valid.apply(get_seconds, axis=1)


# create a new column with run time/num. electronic steps
def get_scaled_time(row):
    time = row["Runtime(s)"]
    elec_steps = row["Electronic Steps"]
    time_per_step = float(time) / float(elec_steps)
    return time_per_step


data_scaled_elec = data_valid
data_scaled_elec["time_per_step"] = data_valid.apply(get_scaled_time, axis=1)

<ipython-input-1-a625ee181dee>:10: SettingWithCopyWarning: 
A value is trying to be set on a copy of a slice from a DataFrame.
Try using .loc[row_indexer,col_indexer] = value instead

See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy
  data_scaled_elec["time_per_step"] = data_valid.apply(get_scaled_time, axis=1)


# create a new column that calculates a "rate" from the scaled time values calculated in the previous cell
def get_scaled_rate(row):
    time_per_step = row["time_per_step"]
    rate = 1.0 / float(time_per_step)
    return rate


data_scaled_elec["scaled_rate"] = data_scaled_elec.apply(get_scaled_rate, axis=1)

<ipython-input-1-553b4b242b1a>:8: SettingWithCopyWarning: 
A value is trying to be set on a copy of a slice from a DataFrame.
Try using .loc[row_indexer,col_indexer] = value instead

See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy
  data_scaled_elec["scaled_rate"] = data_scaled_elec.apply(get_scaled_rate, axis=1)


# correct spelling inconsistencies
# only correcting intel_impi inconsistency and HPC System inconsistency here because these are the only one that has been causing issues so far.
# Haven't checked for others yet
def intel_impi_label(row):
    if row["MPI"] == "intel-impi" or row["MPI"] == "intel_impi":
        return "intel_impi"
    if row["MPI"] == "intel_impi_clara" or row["MPI"] == "intel_impi-clara":
        return "intel_impi_clara"
    else:
        return row["MPI"]


def HPC_sys_label(row):
    if row["HPC System"] == "Swift" or row["HPC System"] == "swift":
        return "Swift"
    elif row["HPC System"] == "Eagle" or row["HPC System"] == "eagle":
        return "Eagle"
    if row["HPC System"] == "Vermillion" or row["HPC System"] == "vermillion":
        return "Vermillion"
    else:
        return row["HPC System"]


data_valid["MPI"] = data_valid.apply(intel_impi_label, axis=1)
data_valid["HPC System"] = data_valid.apply(HPC_sys_label, axis=1)

<ipython-input-1-992d4abd197c>:24: SettingWithCopyWarning: 
A value is trying to be set on a copy of a slice from a DataFrame.
Try using .loc[row_indexer,col_indexer] = value instead

See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy
  data_valid["MPI"] = data_valid.apply(intel_impi_label, axis=1)
<ipython-input-1-992d4abd197c>:25: SettingWithCopyWarning: 
A value is trying to be set on a copy of a slice from a DataFrame.
Try using .loc[row_indexer,col_indexer] = value instead

See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy
  data_valid["HPC System"] = data_valid.apply(HPC_sys_label, axis=1)


def get_processor(row):
    partition = row["Partition"]
    if "gpu" in partition:
        return "GPU"
    else:
        return "CPU"


data_scaled_elec["Processor"] = data_scaled_elec.apply(get_processor, axis=1)

<ipython-input-1-4408d97578ae>:9: SettingWithCopyWarning: 
A value is trying to be set on a copy of a slice from a DataFrame.
Try using .loc[row_indexer,col_indexer] = value instead

See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy
  data_scaled_elec["Processor"] = data_scaled_elec.apply(get_processor, axis=1)


# view data scaled by number of electronic steps
data_scaled_elec


# define a function that calculates performance time scaling two values of a given parameter for a data frame


def get_scaling(df, column, val1, val2):
    kpoints_increase = []
    df_val1 = df[df[column] == val1]
    df_val2 = df[df[column] == val2]
    for cores in np.unique(df_val1["Cores"]):
        if cores in np.unique(df_val2["Cores"]):
            df_val1_time = df_val1[df_val1["Cores"] == cores]["time_per_step"]
            df_val2_time = df_val2[df_val2["Cores"] == cores]["time_per_step"]
            df_val1_avg = np.average(df_val1_time.to_numpy())
            df_val2_avg = np.average(df_val2_time.to_numpy())
            kpoints_increase.append(float(df_val1_avg) / float(df_val2_avg))
    return np.average(kpoints_increase)


data_eagle = data_scaled_elec[data_scaled_elec["HPC System"] == "Eagle"]


data_eagle_2 = data_eagle[data_eagle["Benchmark Code"] == "2"]


data_eagle_2_no_gpu = data_eagle_2[data_eagle_2["Partition"] != "gpu"]

fig = px.scatter(
    data_eagle_2_no_gpu,
    x="Cores",
    y="scaled_rate",
    color="node_fill",
    hover_data=[
        "HPC System",
        "Partition",
        "Nodes",
        "cpu-bind",
        "MPI",
        "Benchmark Code",
    ],
    labels={"scaled_rate": "Rate(1/s)/Electronic Steps"},
    title="Benchmark 2 on Eagle",
)
fig.show()


proportion = get_scaling(data_eagle_2_no_gpu, "node_fill", "half", "full")
print(
    "Using the same number of cores, calculations on half-filled nodes run in an average of",
    proportion,
    "the amount of time as calculations on full nodes.",
)

Using the same number of cores, calculations on half-filled nodes run in an average of 0.8121484814769462 the amount of time as calculations on full nodes.


fig = px.scatter(
    data_eagle_2,
    x="Cores",
    y="scaled_rate",
    color="node_fill",
    hover_data=[
        "HPC System",
        "Partition",
        "Nodes",
        "cpu-bind",
        "MPI",
        "Benchmark Code",
    ],
    labels={"scaled_rate": "Rate(1/s)/Electronic Steps"},
    title="Benchmark 2 on Eagle",
)
fig.show()


data_eagle_2_full = data_eagle_2[data_eagle_2["node_fill"] == "full"]
data_eagle_2_half = data_eagle_2[data_eagle_2["node_fill"] == "half"]
data_eagle_2_gpu = data_eagle_2[data_eagle_2["Partition"] == "gpu"]


fig = px.scatter(
    data_eagle_2_full,
    x="Cores",
    y="scaled_rate",
    color="MPI",
    hover_data=[
        "HPC System",
        "Partition",
        "Nodes",
        "cpu-bind",
        "MPI",
        "Benchmark Code",
    ],
    labels={"scaled_rate": "Rate(1/s)/Electronic Steps"},
    title="Benchmark 2 on Eagle (Full Nodes)",
)
fig.show()


proportion = get_scaling(data_eagle_2_full, "MPI", "openmpi", "intel_impi")
print(
    "On full nodes, calculations using openmpi run in an average of",
    proportion,
    "the amount of time as calculations using intel mpi.",
)

On full nodes, calculations using openmpi run in an average of 1.0056527077811492 the amount of time as calculations using intel mpi.


fig = px.scatter(
    data_eagle_2_half,
    x="Cores",
    y="scaled_rate",
    color="MPI",
    hover_data=[
        "HPC System",
        "Partition",
        "Nodes",
        "cpu-bind",
        "MPI",
        "Benchmark Code",
    ],
    labels={"scaled_rate": "Rate(1/s)/Electronic Steps"},
    title="Benchmark 2 on Eagle (Half-filled Nodes)",
)
fig.show()


proportion = get_scaling(data_eagle_2_half, "MPI", "openmpi", "intel_impi")
print(
    "On full nodes, calculations using openmpi run in an average of",
    proportion,
    "the amount of time as calculations using intel mpi.",
)

On full nodes, calculations using openmpi run in an average of 1.0046683320952752 the amount of time as calculations using intel mpi.


fig = px.scatter(
    data_eagle_2_gpu,
    x="Cores",
    y="scaled_rate",
    color="MPI",
    hover_data=[
        "HPC System",
        "Partition",
        "Nodes",
        "cpu-bind",
        "MPI",
        "Benchmark Code",
    ],
    labels={"scaled_rate": "Rate(1/s)/Electronic Steps"},
    title="Benchmark 2 on Eagle (GPUs)",
)
fig.show()


proportion = get_scaling(data_eagle_2_gpu, "MPI", "openmpi", "intel_impi")
print(
    "On full nodes, calculations using openmpi run in an average of",
    proportion,
    "the amount of time as calculations using intel mpi.",
)

On full nodes, calculations using openmpi run in an average of 0.9931735233077907 the amount of time as calculations using intel mpi.


fig = px.scatter(
    data_eagle_2_full,
    x="Cores",
    y="scaled_rate",
    color="cpu-bind",
    hover_data=[
        "HPC System",
        "Partition",
        "Nodes",
        "cpu-bind",
        "MPI",
        "Benchmark Code",
    ],
    labels={"scaled_rate": "Rate(1/s)/Electronic Steps"},
    title="Benchmark 2 on Eagle (Full Nodes)",
)
fig.show()


proportion_rank = get_scaling(data_eagle_2_full, "cpu-bind", "rank", "none")
print(
    "On average, calculations on full nodes with --cpu-bind=rank run in",
    proportion_rank,
    "the amount of time as calculations without --cpu-bind.",
)

proportion_cores = get_scaling(data_eagle_2_full, "cpu-bind", "cores", "none")
print(
    "\nOn average, calculations on full nodes with --cpu-bind=cores run in",
    proportion_cores,
    "the amount of time as calculations without --cpu-bind.",
)

On average, calculations on full nodes with --cpu-bind=rank run in 0.9604925132123258 the amount of time as calculations without --cpu-bind.

On average, calculations on full nodes with --cpu-bind=cores run in 1.1009252330938635 the amount of time as calculations without --cpu-bind.


fig = px.scatter(
    data_eagle_2_half,
    x="Cores",
    y="scaled_rate",
    color="cpu-bind",
    hover_data=[
        "HPC System",
        "Partition",
        "Nodes",
        "cpu-bind",
        "MPI",
        "Benchmark Code",
    ],
    labels={"scaled_rate": "Rate(1/s)/Electronic Steps"},
    title="Benchmark 2 on Eagle (Half-filled Nodes)",
)
fig.show()


proportion_rank = get_scaling(data_eagle_2_half, "cpu-bind", "rank", "none")
print(
    "On average, calculations on half-filled nodes with --cpu-bind=rank run in",
    proportion_rank,
    "the amount of time as calculations without --cpu-bind.",
)

proportion_cores = get_scaling(data_eagle_2_half, "cpu-bind", "cores", "none")
print(
    "\nOn average, calculations on half-filled nodes with --cpu-bind=cores run in",
    proportion_cores,
    "the amount of time as calculations without --cpu-bind.",
)

On average, calculations on half-filled nodes with --cpu-bind=rank run in 1.1625471216271008 the amount of time as calculations without --cpu-bind.

On average, calculations on half-filled nodes with --cpu-bind=cores run in 0.9182058959786629 the amount of time as calculations without --cpu-bind.


fig = px.scatter(
    data_eagle_2_gpu,
    x="Cores",
    y="scaled_rate",
    color="cpu-bind",
    hover_data=[
        "HPC System",
        "Partition",
        "Nodes",
        "cpu-bind",
        "MPI",
        "Benchmark Code",
    ],
    labels={"scaled_rate": "Rate(1/s)/Electronic Steps"},
    title="Benchmark 2 on Eagle (GPUs)",
)
fig.show()


proportion_rank = get_scaling(data_eagle_2_gpu, "cpu-bind", "rank", "none")
print(
    "On average, calculations on gpu nodes with --cpu-bind=rank run in",
    proportion_rank,
    "the amount of time as calculations without --cpu-bind.",
)

proportion_cores = get_scaling(data_eagle_2_gpu, "cpu-bind", "cores", "none")
print(
    "\nOn average, calculations on gpu nodes with --cpu-bind=cores run in",
    proportion_cores,
    "the amount of time as calculations without --cpu-bind.",
)

On average, calculations on gpu nodes with --cpu-bind=rank run in 1.0505241809518926 the amount of time as calculations without --cpu-bind.

On average, calculations on gpu nodes with --cpu-bind=cores run in 1.0065700737595995 the amount of time as calculations without --cpu-bind.


print(get_scaling(data_eagle_2_gpu, "cpu-bind", "cores", "none"))
print(get_scaling(data_eagle_2_gpu, "cpu-bind", "rank", "none"))

1.0065700737595995
1.0505241809518926


data_eagle_1 = data_eagle[data_eagle["Benchmark Code"] == "1"]


data_eagle_1_K1 = data_eagle_1[data_eagle_1["KPAR"] == 1]
data_eagle_1_K4 = data_eagle_1[data_eagle_1["KPAR"] == 4]
data_eagle_1_K9 = data_eagle_1[data_eagle_1["KPAR"] == 9]

data_eagle_1_K1_N4 = data_eagle_1_K1[data_eagle_1_K1["NPAR"] == "4"]
data_eagle_1_K1_ND = data_eagle_1_K1[data_eagle_1_K1["NPAR"] == "D"]
data_eagle_1_K1_Nsqrt = data_eagle_1_K1[data_eagle_1_K1["NPAR"] == "sqrt"]
data_eagle_1_K4_ND = data_eagle_1_K4[data_eagle_1_K4["NPAR"] == "D"]
data_eagle_1_K9_N4 = data_eagle_1_K9[data_eagle_1_K9["NPAR"] == "4"]
data_eagle_1_K4_Nsqrt = data_eagle_1_K4[data_eagle_1_K4["NPAR"] == "sqrt"]
data_eagle_1_K4_N4 = data_eagle_1_K4[data_eagle_1_K4["NPAR"] == "4"]
data_eagle_1_K9_Nsqrt = data_eagle_1_K9[data_eagle_1_K9["NPAR"] == "sqrt"]


# define a new function that alters the get_scaling function to compare two KPAR/NPAR configurations


def find_nearest(array, value):
    array = [int(i) for i in array]
    array = np.asarray(array)
    idx = (np.abs(array - value)).argmin()
    return array[idx]


def get_scaling_KN(df1, df2, kpoints):
    kpoints_increase = []
    df1 = df1[df1["kpoints"] == kpoints]
    df2 = df2[df2["kpoints"] == kpoints]
    for cores_1 in np.unique(df1["Cores"]):
        cores_2 = find_nearest(np.unique(df2["Cores"]), cores_1)
        if np.abs(cores_2 - cores_1) < 3:
            df1_time = df1[df1["Cores"] == cores_1]["time_per_step"]
            df2_time = df2[df2["Cores"] == cores_2]["time_per_step"]
            df1_avg = np.average(df1_time.to_numpy())
            df2_avg = np.average(df2_time.to_numpy())
            kpoints_increase.append(float(df1_avg) / float(df2_avg))
    return np.average(kpoints_increase)


fig = px.scatter(
    data_eagle_1_K1_N4,
    x="Cores",
    y="scaled_rate",
    color="kpoints",
    symbol="HPC System",
    hover_data=[
        "HPC System",
        "Partition",
        "Nodes",
        "cpu-bind",
        "MPI",
        "Benchmark Code",
    ],
    labels={"Rate": "Rate(s)"},
    title="Benchmark 1 on Eagle: KPAR=1, NPAR=4",
)
fig.show()


proportion = get_scaling(data_eagle_1_K1_N4, "kpoints", "4x4x2", "10x10x5")
print(
    "On average, 4x4x2 kpoints grid calculations run in ",
    proportion,
    "the amount of time as the 10x10x5 kpoints grid calculations",
)

On average, 4x4x2 kpoints grid calculations run in  0.2158856898471929 the amount of time as the 10x10x5 kpoints grid calculations


proportion_4x4x2 = get_scaling_KN(data_eagle_1_K1_N4, data_eagle_1_K1_ND, "4x4x2")
proportion_10x10x5 = get_scaling_KN(data_eagle_1_K1_N4, data_eagle_1_K1_ND, "10x10x5")
print(
    "On average, using a 4x4x2 kpoints grid, calculations with KPAR=1, NPAR=4 ran in",
    proportion_4x4x2,
    "the amount of time needed for calculations with the default KPAR/NPAR settings.",
)
print(
    "\nOn average, using a 10x10x5 kpoints grid, calculations with KPAR=1, NPAR=4 ran in",
    proportion_10x10x5,
    "the amount of time needed for calculations with the default KPAR/NPAR settings.",
)

On average, using a 4x4x2 kpoints grid, calculations with KPAR=1, NPAR=4 ran in 0.6430988260472635 the amount of time needed for calculations with the default KPAR/NPAR settings.

On average, using a 10x10x5 kpoints grid, calculations with KPAR=1, NPAR=4 ran in 0.7126574907286309 the amount of time needed for calculations with the default KPAR/NPAR settings.


fig = px.scatter(
    data_eagle_1_K1_ND,
    x="Cores",
    y="scaled_rate",
    color="kpoints",
    symbol="HPC System",
    hover_data=[
        "HPC System",
        "Partition",
        "Nodes",
        "cpu-bind",
        "MPI",
        "Benchmark Code",
    ],
    labels={"Rate": "Rate(s)"},
    title="Benchmark 1 on Eagle: KPAR=1, NPAR=# of cores",
)
fig.show()


proportion = get_scaling(data_eagle_1_K1_ND, "kpoints", "4x4x2", "10x10x5")
print(
    "On average, 4x4x2 kpoints grid calculations run in ",
    proportion,
    "the amount of time as the 10x10x5 kpoints grid calculations",
)

On average, 4x4x2 kpoints grid calculations run in  0.2014703092116728 the amount of time as the 10x10x5 kpoints grid calculations


fig = px.scatter(
    data_eagle_1_K1_Nsqrt,
    x="Cores",
    y="scaled_rate",
    color="kpoints",
    symbol="HPC System",
    hover_data=[
        "HPC System",
        "Partition",
        "Nodes",
        "cpu-bind",
        "MPI",
        "Benchmark Code",
    ],
    labels={"Rate": "Rate(s)"},
    title="Benchmark 1 on Eagle: KPAR=1, NPAR=sqrt",
)
fig.show()


proportion = get_scaling(data_eagle_1_K1_Nsqrt, "kpoints", "4x4x2", "10x10x5")
print(
    "On average, 4x4x2 kpoints grid calculations run in ",
    proportion,
    "the amount of time as the 10x10x5 kpoints grid calculations",
)

On average, 4x4x2 kpoints grid calculations run in  0.2615582479340918 the amount of time as the 10x10x5 kpoints grid calculations


proportion_4x4x2 = get_scaling_KN(data_eagle_1_K1_Nsqrt, data_eagle_1_K1_ND, "4x4x2")
proportion_10x10x5 = get_scaling_KN(
    data_eagle_1_K1_Nsqrt, data_eagle_1_K1_ND, "10x10x5"
)
print(
    "On average, using a 4x4x2 kpoints grid, calculations with KPAR=1, NPAR=sqrt(# of cores) ran in",
    proportion_4x4x2,
    "the amount of time needed for calculations with the default KPAR/NPAR settings.",
)
print(
    "\nOn average, using a 10x10x5 kpoints grid, calculations with KPAR=1, NPAR=sqrt(# of cores) ran in",
    proportion_10x10x5,
    "the amount of time needed for calculations with the default KPAR/NPAR settings.",
)

On average, using a 4x4x2 kpoints grid, calculations with KPAR=1, NPAR=sqrt(# of cores) ran in 0.7847840621014068 the amount of time needed for calculations with the default KPAR/NPAR settings.

On average, using a 10x10x5 kpoints grid, calculations with KPAR=1, NPAR=sqrt(# of cores) ran in 0.6991603785432458 the amount of time needed for calculations with the default KPAR/NPAR settings.


fig = px.scatter(
    data_eagle_1_K4_ND,
    x="Cores",
    y="scaled_rate",
    color="kpoints",
    symbol="HPC System",
    hover_data=[
        "HPC System",
        "Nodes",
        "Partition",
        "cpu-bind",
        "MPI",
        "Benchmark Code",
    ],
    labels={"Rate": "Rate(s)"},
    title="Benchmark 1 on Eagle: KPAR=4, NPAR=# of cores",
)
fig.show()


proportion = get_scaling(data_eagle_1_K4_ND, "kpoints", "4x4x2", "10x10x5")
print(
    "On average, 4x4x2 kpoints grid calculations run in ",
    proportion,
    "the amount of time as the 10x10x5 kpoints grid calculations",
)

On average, 4x4x2 kpoints grid calculations run in  0.2627675712217573 the amount of time as the 10x10x5 kpoints grid calculations


proportion_4x4x2 = get_scaling_KN(data_eagle_1_K4_ND, data_eagle_1_K1_ND, "4x4x2")
proportion_10x10x5 = get_scaling_KN(data_eagle_1_K4_ND, data_eagle_1_K1_ND, "10x10x5")
print(
    "On average, using a 4x4x2 kpoints grid, calculations with KPAR=1, NPAR=# of cores ran in",
    proportion_4x4x2,
    "the amount of time needed for calculations with the default KPAR/NPAR settings.",
)
print(
    "\nOn average, using a 10x10x5 kpoints grid, calculations with KPAR=1, NPAR=# of cores ran in",
    proportion_10x10x5,
    "the amount of time needed for calculations with the default KPAR/NPAR settings.",
)

On average, using a 4x4x2 kpoints grid, calculations with KPAR=1, NPAR=# of cores ran in 0.3661494297317568 the amount of time needed for calculations with the default KPAR/NPAR settings.

On average, using a 10x10x5 kpoints grid, calculations with KPAR=1, NPAR=# of cores ran in 0.40966266250690236 the amount of time needed for calculations with the default KPAR/NPAR settings.


fig = px.scatter(
    data_eagle_1_K9_N4,
    x="Cores",
    y="scaled_rate",
    color="kpoints",
    symbol="HPC System",
    hover_data=[
        "HPC System",
        "Partition",
        "Nodes",
        "cpu-bind",
        "MPI",
        "Benchmark Code",
    ],
    labels={"Rate": "Rate(s)"},
    title="Benchmark 1 on Eagle: KPAR=9, NPAR=4",
)
fig.show()


proportion = get_scaling(data_eagle_1_K9_N4, "kpoints", "4x4x2", "10x10x5")
print(
    "On average, 4x4x2 kpoints grid calculations run in ",
    proportion,
    "the amount of time as the 10x10x5 kpoints grid calculations",
)

On average, 4x4x2 kpoints grid calculations run in  0.41407912054742224 the amount of time as the 10x10x5 kpoints grid calculations


proportion_4x4x2 = get_scaling_KN(data_eagle_1_K9_N4, data_eagle_1_K1_ND, "4x4x2")
proportion_10x10x5 = get_scaling_KN(data_eagle_1_K9_N4, data_eagle_1_K1_ND, "10x10x5")
print(
    "On average, using a 4x4x2 kpoints grid, calculations with KPAR=9, NPAR=4",
    proportion_4x4x2,
    "the amount of time needed for calculations with the default KPAR/NPAR settings.",
)
print(
    "\nOn average, using a 10x10x5 kpoints grid, calculations with KPAR=9, NPAR=4",
    proportion_10x10x5,
    "the amount of time needed for calculations with the default KPAR/NPAR settings.",
)

On average, using a 4x4x2 kpoints grid, calculations with KPAR=9, NPAR=4 0.7090692212812519 the amount of time needed for calculations with the default KPAR/NPAR settings.

On average, using a 10x10x5 kpoints grid, calculations with KPAR=9, NPAR=4 0.5844413364433881 the amount of time needed for calculations with the default KPAR/NPAR settings.


fig = px.scatter(
    data_eagle_1_K4_Nsqrt,
    x="Cores",
    y="scaled_rate",
    color="kpoints",
    symbol="HPC System",
    hover_data=[
        "HPC System",
        "Partition",
        "Nodes",
        "cpu-bind",
        "MPI",
        "Benchmark Code",
    ],
    labels={"Rate": "Rate(s)"},
    title="Benchmark 1 on Eagle: KPAR=4, NPAR=sqrt",
)
fig.show()


proportion = get_scaling(data_eagle_1_K4_Nsqrt, "kpoints", "4x4x2", "10x10x5")
print(
    "On average, 4x4x2 kpoints grid calculations run in ",
    proportion,
    "the amount of time as the 10x10x5 kpoints grid calculations",
)

On average, 4x4x2 kpoints grid calculations run in  0.22617692814102044 the amount of time as the 10x10x5 kpoints grid calculations


proportion_4x4x2 = get_scaling_KN(data_eagle_1_K4_Nsqrt, data_eagle_1_K1_ND, "4x4x2")
proportion_10x10x5 = get_scaling_KN(
    data_eagle_1_K4_Nsqrt, data_eagle_1_K1_ND, "10x10x5"
)
print(
    "On average, using a 4x4x2 kpoints grid, calculations with KPAR=4, NPAR=sqrt(# of cores ran in)",
    proportion_4x4x2,
    "the amount of time needed for calculations with the default KPAR/NPAR settings.",
)
print(
    "\nOn average, using a 10x10x5 kpoints grid, calculations with KPAR=4, NPAR=sqrt(# of cores ran in)",
    proportion_10x10x5,
    "the amount of time needed for calculations with the default KPAR/NPAR settings.",
)

On average, using a 4x4x2 kpoints grid, calculations with KPAR=4, NPAR=sqrt(# of cores ran in) 0.35381217524785147 the amount of time needed for calculations with the default KPAR/NPAR settings.

On average, using a 10x10x5 kpoints grid, calculations with KPAR=4, NPAR=sqrt(# of cores ran in) 0.5649568803141125 the amount of time needed for calculations with the default KPAR/NPAR settings.


fig = px.scatter(
    data_eagle_1_K4_N4,
    x="Cores",
    y="scaled_rate",
    color="kpoints",
    symbol="HPC System",
    hover_data=[
        "HPC System",
        "Partition",
        "Nodes",
        "cpu-bind",
        "MPI",
        "Benchmark Code",
    ],
    labels={"Rate": "Rate(s)"},
    title="Benchmark 1 on Eagle: KPAR=4, NPAR=4",
)
fig.show()


proportion = get_scaling(data_eagle_1_K4_N4, "kpoints", "4x4x2", "10x10x5")
print(
    "On average, 4x4x2 kpoints grid calculations run in ",
    proportion,
    "the amount of time as the 10x10x5 kpoints grid calculations",
)

On average, 4x4x2 kpoints grid calculations run in  0.23828639659359566 the amount of time as the 10x10x5 kpoints grid calculations


proportion_4x4x2 = get_scaling_KN(data_eagle_1_K4_N4, data_eagle_1_K1_ND, "4x4x2")
proportion_10x10x5 = get_scaling_KN(data_eagle_1_K4_N4, data_eagle_1_K1_ND, "10x10x5")
print(
    "On average, using a 4x4x2 kpoints grid, calculations with KPAR=4, NPAR=4",
    proportion_4x4x2,
    "the amount of time needed for calculations with the default KPAR/NPAR settings.",
)
print(
    "\nOn average, using a 10x10x5 kpoints grid, calculations with KPAR=4, NPAR=4",
    proportion_10x10x5,
    "the amount of time needed for calculations with the default KPAR/NPAR settings.",
)

On average, using a 4x4x2 kpoints grid, calculations with KPAR=4, NPAR=4 0.3628997338251977 the amount of time needed for calculations with the default KPAR/NPAR settings.

On average, using a 10x10x5 kpoints grid, calculations with KPAR=4, NPAR=4 0.42714837712868303 the amount of time needed for calculations with the default KPAR/NPAR settings.


fig = px.scatter(
    data_eagle_1_K9_Nsqrt,
    x="Cores",
    y="scaled_rate",
    color="kpoints",
    symbol="HPC System",
    hover_data=[
        "HPC System",
        "Partition",
        "Nodes",
        "cpu-bind",
        "MPI",
        "Benchmark Code",
    ],
    labels={"Rate": "Rate(s)"},
    title="Benchmark 1 on Eagle: KPAR=9, NPAR=9",
)
fig.show()


proportion = get_scaling(data_eagle_1_K9_Nsqrt, "kpoints", "4x4x2", "10x10x5")
print(
    "On average, 4x4x2 kpoints grid calculations run in ",
    proportion,
    "the amount of time as the 10x10x5 kpoints grid calculations",
)

On average, 4x4x2 kpoints grid calculations run in  0.2751181088121913 the amount of time as the 10x10x5 kpoints grid calculations


proportion_4x4x2 = get_scaling_KN(data_eagle_1_K9_Nsqrt, data_eagle_1_K1_ND, "4x4x2")
proportion_10x10x5 = get_scaling_KN(
    data_eagle_1_K9_Nsqrt, data_eagle_1_K1_ND, "10x10x5"
)
print(
    "On average, using a 4x4x2 kpoints grid, calculations with KPAR=9, NPAR=sqrt(# of cores)",
    proportion_4x4x2,
    "the amount of time needed for calculations with the default KPAR/NPAR settings.",
)
print(
    "\nOn average, using a 10x10x5 kpoints grid, calculations with KPAR=9, NPAR=sqrt(# of cores)",
    proportion_10x10x5,
    "the amount of time needed for calculations with the default KPAR/NPAR settings.",
)

On average, using a 4x4x2 kpoints grid, calculations with KPAR=9, NPAR=sqrt(# of cores) 0.718825197761971 the amount of time needed for calculations with the default KPAR/NPAR settings.

On average, using a 10x10x5 kpoints grid, calculations with KPAR=9, NPAR=sqrt(# of cores) 0.5942041449053749 the amount of time needed for calculations with the default KPAR/NPAR settings.


fig = px.scatter(
    data_eagle_1_K9_N4,
    x="Cores",
    y="scaled_rate",
    color="MPI",
    symbol="kpoints",
    hover_data=[
        "HPC System",
        "Partition",
        "Nodes",
        "cpu-bind",
        "MPI",
        "Benchmark Code",
    ],
    labels={"scaled_rate": "Rate(1/s)/Electronic Steps"},
    title="Benchmark 1 on Eagle",
)
fig.show()


proportion = get_scaling(data_eagle_1_K9_N4, "MPI", "openmpi", "intel_impi")
print(
    "Calculations using openmpi run in an average of",
    proportion,
    "the amount of time as calculations using intel mpi.",
)

Calculations using openmpi run in an average of 1.0254375511756568 the amount of time as calculations using intel mpi.


fig = px.scatter(
    data_eagle_1_K9_N4,
    x="Cores",
    y="scaled_rate",
    color="cpu-bind",
    symbol="kpoints",
    hover_data=[
        "HPC System",
        "Partition",
        "Nodes",
        "cpu-bind",
        "MPI",
        "Benchmark Code",
    ],
    labels={"scaled_rate": "Rate(1/s)/Electronic Steps"},
    title="Benchmark 1 on Eagle",
)
fig.show()


proportion_rank = get_scaling(data_eagle_1_K9_N4, "cpu-bind", "rank", "none")
proportion_cores = get_scaling(data_eagle_1_K9_N4, "cpu-bind", "cores", "none")
print(
    "Calculations using --cpu-bind=rank run in an average of",
    proportion_rank,
    "the amount of time as calculations without --cpu-bind.",
)
print(
    "\nCalculations using --cpu-bind=cores run in an average of",
    proportion_cores,
    "the amount of time as calculations without --cpu-bind.",
)

Calculations using --cpu-bind=rank run in an average of 0.9701700624438857 the amount of time as calculations without --cpu-bind.

Calculations using --cpu-bind=cores run in an average of 1.1259091578496088 the amount of time as calculations without --cpu-bind.


data_swift = data_scaled_elec[data_scaled_elec["HPC System"] == "Swift"]


data_swift_2 = data_swift[data_swift["Benchmark Code"] == "2"]


fig = px.scatter(
    data_swift_2,
    x="Cores",
    y="scaled_rate",
    color="node_fill",
    hover_data=[
        "HPC System",
        "Partition",
        "Nodes",
        "cpu-bind",
        "MPI",
        "Benchmark Code",
    ],
    labels={"scaled_rate": "Rate(1/s)/Electronic Steps"},
    title="Benchmark 2 on Swift",
)
fig.show()


data_swift_2_impi = data_swift_2[data_swift_2["MPI"]=="intel_impi"]
data_swift_2_openmpi = data_swift_2[data_swift_2["MPI"]=="openmpi"]

proportion_impi = get_scaling(data_swift_2_impi, "node_fill", "half", "full")
proportion_openmpi = get_scaling(data_swift_2_openmpi, "node_fill", "half", "full")

print("Intel MPI: On average, calculations running on half-filled nodes run in ",proportion_impi,"the amount of time as calculations running on full nodes with same number of cores")
print("\nOpenMPI: On average, calculations running on half-filled nodes run in ",proportion_openmpi,"the amount of time as calculations running on full nodes with same number of cores")

Intel MPI: On average, calculations running on half-filled nodes run in  0.8372589810827744 the amount of time as calculations running on full nodes with same number of cores

OpenMPI: On average, calculations running on half-filled nodes run in  0.7460202698705677 the amount of time as calculations running on full nodes with same number of cores


data_swift_2_full = data_swift_2[data_swift_2["node_fill"] == "full"]
data_swift_2_half = data_swift_2[data_swift_2["node_fill"] == "half"]


fig = px.scatter(
    data_swift_2_full,
    x="Cores",
    y="scaled_rate",
    color="MPI",
    hover_data=[
        "HPC System",
        "Partition",
        "Nodes",
        "cpu-bind",
        "MPI",
        "Benchmark Code",
    ],
    labels={"scaled_rate": "Rate(1/s)/Electronic Steps"},
    title="Benchmark 2 on Swift (Full Nodes)",
)
fig.show()


proportion = get_scaling(data_swift_2_full, "MPI", "intel_impi", "openmpi")
print(
    "On average, calculations running on full nodes using Intel MPI run in",
    proportion,
    "the amount of time as calculations using OpenMPI",
)

On average, calculations running on full nodes using Intel MPI run in 0.5240630467696896 the amount of time as calculations using OpenMPI


fig = px.scatter(
    data_swift_2_half,
    x="Cores",
    y="scaled_rate",
    color="MPI",
    hover_data=[
        "HPC System",
        "Partition",
        "Nodes",
        "cpu-bind",
        "MPI",
        "Benchmark Code",
    ],
    labels={"scaled_rate": "Rate(1/s)/Electronic Steps"},
    title="Benchmark 2 on Swift (Half Nodes)",
)
fig.show()


proportion = get_scaling(data_swift_2_half, "MPI", "intel_impi", "openmpi")
print(
    "On average, calculations running on half-filled nodes using Intel MPI run in",
    proportion,
    "the amount of time as calculations using OpenMPI",
)

On average, calculations running on half-filled nodes using Intel MPI run in 0.7177494200819271 the amount of time as calculations using OpenMPI


fig = px.scatter(
    data_swift_2_full,
    x="Cores",
    y="scaled_rate",
    color="cpu-bind",
    hover_data=[
        "HPC System",
        "Partition",
        "Nodes",
        "cpu-bind",
        "MPI",
        "Benchmark Code",
    ],
    labels={"scaled_rate": "Rate(1/s)/Electronic Steps"},
    title="Benchmark 2 on Swift (Full Nodes)",
)
fig.show()


proportion_rank = get_scaling(data_swift_2_full, "cpu-bind", "rank", "none")
print(
    "On average, calculations on full nodes with --cpu-bind=rank run in",
    proportion_rank,
    "the amount of time as calculations without --cpu-bind.",
)

proportion_cores = get_scaling(data_swift_2_full, "cpu-bind", "cores", "none")
print(
    "\nOn average, calculations on full nodes with --cpu-bind=cores run in",
    proportion_cores,
    "the amount of time as calculations without --cpu-bind.",
)

On average, calculations on full nodes with --cpu-bind=rank run in 0.885298044547332 the amount of time as calculations without --cpu-bind.

On average, calculations on full nodes with --cpu-bind=cores run in 0.9323764171503093 the amount of time as calculations without --cpu-bind.


fig = px.scatter(
    data_swift_2_half,
    x="Cores",
    y="scaled_rate",
    color="cpu-bind",
    hover_data=[
        "HPC System",
        "Partition",
        "Nodes",
        "cpu-bind",
        "MPI",
        "Benchmark Code",
    ],
    labels={"scaled_rate": "Rate(1/s)/Electronic Steps"},
    title="Benchmark 2 on Swift (Half Nodes)",
)
fig.show()


proportion_rank = get_scaling(data_swift_2_half, "cpu-bind", "rank", "none")
print(
    "On average, calculations on half-filled nodes with --cpu-bind=rank run in",
    proportion_rank,
    "the amount of time as calculations without --cpu-bind.",
)

proportion_cores = get_scaling(data_swift_2_half, "cpu-bind", "cores", "none")
print(
    "\nOn average, calculations on half-filled nodes with --cpu-bind=cores run in",
    proportion_cores,
    "the amount of time as calculations without --cpu-bind.",
)

On average, calculations on half-filled nodes with --cpu-bind=rank run in 1.3483218840678666 the amount of time as calculations without --cpu-bind.

On average, calculations on half-filled nodes with --cpu-bind=cores run in 1.1269873562506034 the amount of time as calculations without --cpu-bind.


data_swift_1 = data_swift[data_swift["Benchmark Code"] == "1"]

data_swift_1_4x4x2 = data_swift_1[data_swift_1["kpoints"] == "4x4x2"]
data_swift_1_10x10x5 = data_swift_1[data_swift_1["kpoints"] == "10x10x5"]


data_swift_1_K1 = data_swift_1[data_swift_1["KPAR"] == 1]
data_swift_1_K4 = data_swift_1[data_swift_1["KPAR"] == 4]
data_swift_1_K9 = data_swift_1[data_swift_1["KPAR"] == 9]

data_swift_1_K1_N4 = data_swift_1_K1[data_swift_1_K1["NPAR"] == "4"]
data_swift_1_K1_ND = data_swift_1_K1[data_swift_1_K1["NPAR"] == "D"]
data_swift_1_K1_Nsqrt = data_swift_1_K1[data_swift_1_K1["NPAR"] == "sqrt"]
data_swift_1_K4_ND = data_swift_1_K4[data_swift_1_K4["NPAR"] == "D"]
data_swift_1_K9_N4 = data_swift_1_K9[data_swift_1_K9["NPAR"] == "4"]
data_swift_1_K4_Nsqrt = data_swift_1_K4[data_swift_1_K4["NPAR"] == "sqrt"]
data_swift_1_K4_N4 = data_swift_1_K4[data_swift_1_K4["NPAR"] == "4"]
data_swift_1_K9_Nsqrt = data_swift_1_K9[data_swift_1_K9["NPAR"] == "sqrt"]


fig = px.scatter(
    data_swift_1_K1_N4,
    x="Cores",
    y="scaled_rate",
    color="kpoints",
    symbol="HPC System",
    hover_data=[
        "HPC System",
        "Partition",
        "Nodes",
        "cpu-bind",
        "MPI",
        "Benchmark Code",
    ],
    labels={"Rate": "Rate(s)"},
    title="Benchmark 1 on Swift: KPAR=1, NPAR=4",
)
fig.show()


proportion = get_scaling(data_swift_1_K1_N4, "kpoints", "4x4x2", "10x10x5")
print(
    "On average, 4x4x2 kpoints grid calculations run in ",
    proportion,
    "the amount of time as the 10x10x5 kpoints grid calculations",
)

On average, 4x4x2 kpoints grid calculations run in  0.1975141522550828 the amount of time as the 10x10x5 kpoints grid calculations


proportion_4x4x2 = get_scaling_KN(data_swift_1_K1_N4, data_swift_1_K1_ND, "4x4x2")
proportion_10x10x5 = get_scaling_KN(data_swift_1_K1_N4, data_swift_1_K1_ND, "10x10x5")
print(
    "On average, using a 4x4x2 kpoints grid, calculations with KPAR=1, NPAR=4",
    proportion_4x4x2,
    "the amount of time needed for calculations with the default KPAR/NPAR settings.",
)
print(
    "\nOn average, using a 10x10x5 kpoints grid, calculations with KPAR=1, NPAR=4",
    proportion_10x10x5,
    "the amount of time needed for calculations with the default KPAR/NPAR settings.",
)

On average, using a 4x4x2 kpoints grid, calculations with KPAR=1, NPAR=4 0.5090346292174364 the amount of time needed for calculations with the default KPAR/NPAR settings.

On average, using a 10x10x5 kpoints grid, calculations with KPAR=1, NPAR=4 0.6028076724156124 the amount of time needed for calculations with the default KPAR/NPAR settings.


fig = px.scatter(
    data_swift_1_K1_ND,
    x="Cores",
    y="scaled_rate",
    color="kpoints",
    symbol="HPC System",
    hover_data=[
        "HPC System",
        "Nodes",
        "Partition",
        "cpu-bind",
        "MPI",
        "Benchmark Code",
    ],
    labels={"Rate": "Rate(s)"},
    title="Benchmark 1 on Swift: KPAR=1, NPAR=# of cores",
)
fig.show()


proportion = get_scaling(data_swift_1_K1_ND, "kpoints", "4x4x2", "10x10x5")
print(
    "On average, 4x4x2 kpoints grid calculations run in ",
    proportion,
    "the amount of time as the 10x10x5 kpoints grid calculations",
)

On average, 4x4x2 kpoints grid calculations run in  0.187687779611522 the amount of time as the 10x10x5 kpoints grid calculations


fig = px.scatter(
    data_swift_1_K1_Nsqrt,
    x="Cores",
    y="scaled_rate",
    color="kpoints",
    symbol="HPC System",
    hover_data=[
        "HPC System",
        "Partition",
        "Nodes",
        "cpu-bind",
        "MPI",
        "Benchmark Code",
    ],
    labels={"Rate": "Rate(s)"},
    title="Benchmark 1 on Swift: KPAR=1, NPAR=sqrt",
)
fig.show()


proportion = get_scaling(data_swift_1_K1_Nsqrt, "kpoints", "4x4x2", "10x10x5")
print(
    "On average, 4x4x2 kpoints grid calculations run in ",
    proportion,
    "the amount of time as the 10x10x5 kpoints grid calculations",
)

On average, 4x4x2 kpoints grid calculations run in  0.18557856687555285 the amount of time as the 10x10x5 kpoints grid calculations


proportion_4x4x2 = get_scaling_KN(data_swift_1_K1_Nsqrt, data_swift_1_K1_ND, "4x4x2")
proportion_10x10x5 = get_scaling_KN(
    data_swift_1_K1_Nsqrt, data_swift_1_K1_ND, "10x10x5"
)
print(
    "On average, using a 4x4x2 kpoints grid, calculations with KPAR=1, NPAR=sqrt(# of cores)",
    proportion_4x4x2,
    "the amount of time needed for calculations with the default KPAR/NPAR settings.",
)
print(
    "\nOn average, using a 10x10x5 kpoints grid, calculations with KPAR=1, NPAR=sqrt(# of cores)",
    proportion_10x10x5,
    "the amount of time needed for calculations with the default KPAR/NPAR settings.",
)

On average, using a 4x4x2 kpoints grid, calculations with KPAR=1, NPAR=sqrt(# of cores) 0.8992932111437968 the amount of time needed for calculations with the default KPAR/NPAR settings.

On average, using a 10x10x5 kpoints grid, calculations with KPAR=1, NPAR=sqrt(# of cores) 0.8936429988792207 the amount of time needed for calculations with the default KPAR/NPAR settings.


fig = px.scatter(
    data_swift_1_K4_ND,
    x="Cores",
    y="scaled_rate",
    color="kpoints",
    symbol="HPC System",
    hover_data=[
        "HPC System",
        "Partition",
        "Nodes",
        "cpu-bind",
        "MPI",
        "Benchmark Code",
    ],
    labels={"Rate": "Rate(s)"},
    title="Benchmark 1 on Swift: KPAR=4, NPAR=# of cores",
)
fig.show()


proportion = get_scaling(data_swift_1_K4_ND, "kpoints", "4x4x2", "10x10x5")
print(
    "On average, 4x4x2 kpoints grid calculations run in ",
    proportion,
    "the amount of time as the 10x10x5 kpoints grid calculations",
)

On average, 4x4x2 kpoints grid calculations run in  0.20460889560586515 the amount of time as the 10x10x5 kpoints grid calculations


proportion_4x4x2 = get_scaling_KN(data_swift_1_K4_ND, data_swift_1_K1_ND, "4x4x2")
proportion_10x10x5 = get_scaling_KN(data_swift_1_K4_ND, data_swift_1_K1_ND, "10x10x5")
print(
    "On average, using a 4x4x2 kpoints grid, calculations with KPAR=4, NPAR=# of cores",
    proportion_4x4x2,
    "the amount of time needed for calculations with the default KPAR/NPAR settings.",
)
print(
    "\nOn average, using a 10x10x5 kpoints grid, calculations with KPAR=4, NPAR=sqrt# of cores",
    proportion_10x10x5,
    "the amount of time needed for calculations with the default KPAR/NPAR settings.",
)

On average, using a 4x4x2 kpoints grid, calculations with KPAR=4, NPAR=# of cores 0.3155517478601654 the amount of time needed for calculations with the default KPAR/NPAR settings.

On average, using a 10x10x5 kpoints grid, calculations with KPAR=4, NPAR=sqrt# of cores 0.35680104665469237 the amount of time needed for calculations with the default KPAR/NPAR settings.


fig = px.scatter(
    data_swift_1_K9_N4,
    x="Cores",
    y="scaled_rate",
    color="kpoints",
    symbol="HPC System",
    hover_data=[
        "HPC System",
        "Partition",
        "Nodes",
        "cpu-bind",
        "MPI",
        "Benchmark Code",
    ],
    labels={"Rate": "Rate(s)"},
    title="Benchmark 1 on Swift: KPAR=9, NPAR=4",
)
fig.show()


proportion = get_scaling(data_swift_1_K9_N4, "kpoints", "4x4x2", "10x10x5")
print(
    "On average, 4x4x2 kpoints grid calculations run in ",
    proportion,
    "the amount of time as the 10x10x5 kpoints grid calculations",
)

On average, 4x4x2 kpoints grid calculations run in  0.3409966806834724 the amount of time as the 10x10x5 kpoints grid calculations


proportion_4x4x2 = get_scaling_KN(data_swift_1_K9_N4, data_swift_1_K1_ND, "4x4x2")
proportion_10x10x5 = get_scaling_KN(data_swift_1_K9_N4, data_swift_1_K1_ND, "10x10x5")
print(
    "On average, using a 4x4x2 kpoints grid, calculations with KPAR=9, NPAR=4",
    proportion_4x4x2,
    "the amount of time needed for calculations with the default KPAR/NPAR settings.",
)
print(
    "\nOn average, using a 10x10x5 kpoints grid, calculations with KPAR=9, NPAR=4",
    proportion_10x10x5,
    "the amount of time needed for calculations with the default KPAR/NPAR settings.",
)

On average, using a 4x4x2 kpoints grid, calculations with KPAR=9, NPAR=4 0.37857221589965856 the amount of time needed for calculations with the default KPAR/NPAR settings.

On average, using a 10x10x5 kpoints grid, calculations with KPAR=9, NPAR=4 0.24285269584083571 the amount of time needed for calculations with the default KPAR/NPAR settings.


fig = px.scatter(
    data_swift_1_K4_Nsqrt,
    x="Cores",
    y="scaled_rate",
    color="kpoints",
    symbol="HPC System",
    hover_data=[
        "HPC System",
        "Partition",
        "Nodes",
        "cpu-bind",
        "MPI",
        "Benchmark Code",
    ],
    labels={"Rate": "Rate(s)"},
    title="Benchmark 1 on Swift: KPAR=4, NPAR=sqrt",
)
fig.show()


proportion = get_scaling(data_swift_1_K4_Nsqrt, "kpoints", "4x4x2", "10x10x5")
print(
    "On average, 4x4x2 kpoints grid calculations run in ",
    proportion,
    "the amount of time as the 10x10x5 kpoints grid calculations",
)

On average, 4x4x2 kpoints grid calculations run in  0.19944158617005048 the amount of time as the 10x10x5 kpoints grid calculations


proportion_4x4x2 = get_scaling_KN(data_swift_1_K4_Nsqrt, data_swift_1_K1_ND, "4x4x2")
proportion_10x10x5 = get_scaling_KN(
    data_swift_1_K4_Nsqrt, data_swift_1_K1_ND, "10x10x5"
)
print(
    "On average, using a 4x4x2 kpoints grid, calculations with KPAR=4, NPAR=sqrt(# of cores)",
    proportion_4x4x2,
    "the amount of time needed for calculations with the default KPAR/NPAR settings.",
)
print(
    "\nOn average, using a 10x10x5 kpoints grid, calculations with KPAR=4, NPAR=sqrt(# of cores)",
    proportion_10x10x5,
    "the amount of time needed for calculations with the default KPAR/NPAR settings.",
)

On average, using a 4x4x2 kpoints grid, calculations with KPAR=4, NPAR=sqrt(# of cores) 0.3724752313459252 the amount of time needed for calculations with the default KPAR/NPAR settings.

On average, using a 10x10x5 kpoints grid, calculations with KPAR=4, NPAR=sqrt(# of cores) 0.4301798105777811 the amount of time needed for calculations with the default KPAR/NPAR settings.


fig = px.scatter(
    data_swift_1_K4_N4,
    x="Cores",
    y="scaled_rate",
    color="kpoints",
    symbol="HPC System",
    hover_data=[
        "HPC System",
        "Partition",
        "Nodes",
        "cpu-bind",
        "MPI",
        "Benchmark Code",
    ],
    labels={"Rate": "Rate(s)"},
    title="Benchmark 1 on Swift: KPAR=4, NPAR=4",
)
fig.show()


proportion = get_scaling(data_swift_1_K4_N4, "kpoints", "4x4x2", "10x10x5")
print(
    "On average, 4x4x2 kpoints grid calculations run in ",
    proportion,
    "the amount of time as the 10x10x5 kpoints grid calculations",
)

On average, 4x4x2 kpoints grid calculations run in  0.20699084255595146 the amount of time as the 10x10x5 kpoints grid calculations


proportion_4x4x2 = get_scaling_KN(data_swift_1_K4_N4, data_swift_1_K1_ND, "4x4x2")
proportion_10x10x5 = get_scaling_KN(data_swift_1_K4_N4, data_swift_1_K1_ND, "10x10x5")
print(
    "On average, using a 4x4x2 kpoints grid, calculations with KPAR=4, NPAR=4",
    proportion_4x4x2,
    "the amount of time needed for calculations with the default KPAR/NPAR settings.",
)
print(
    "\nOn average, using a 10x10x5 kpoints grid, calculations with KPAR=4, NPAR=4",
    proportion_10x10x5,
    "the amount of time needed for calculations with the default KPAR/NPAR settings.",
)

On average, using a 4x4x2 kpoints grid, calculations with KPAR=4, NPAR=4 0.29764560579057525 the amount of time needed for calculations with the default KPAR/NPAR settings.

On average, using a 10x10x5 kpoints grid, calculations with KPAR=4, NPAR=4 0.33767965209899 the amount of time needed for calculations with the default KPAR/NPAR settings.


fig = px.scatter(
    data_swift_1_K9_Nsqrt,
    x="Cores",
    y="scaled_rate",
    color="kpoints",
    symbol="HPC System",
    hover_data=[
        "HPC System",
        "Partition",
        "Nodes",
        "cpu-bind",
        "MPI",
        "Benchmark Code",
    ],
    labels={"Rate": "Rate(s)"},
    title="Benchmark 1 on Swift: KPAR=9, NPAR=sqrt",
)
fig.show()


proportion = get_scaling(data_swift_1_K9_Nsqrt, "kpoints", "4x4x2", "10x10x5")
print(
    "On average, 4x4x2 kpoints grid calculations run in ",
    proportion,
    "the amount of time as the 10x10x5 kpoints grid calculations",
)

On average, 4x4x2 kpoints grid calculations run in  0.3192887638021647 the amount of time as the 10x10x5 kpoints grid calculations


proportion_4x4x2 = get_scaling_KN(data_swift_1_K9_Nsqrt, data_swift_1_K1_ND, "4x4x2")
proportion_10x10x5 = get_scaling_KN(
    data_swift_1_K9_Nsqrt, data_swift_1_K1_ND, "10x10x5"
)
print(
    "On average, using a 4x4x2 kpoints grid, calculations with KPAR=9, NPAR=sqrt(# of cores)",
    proportion_4x4x2,
    "the amount of time needed for calculations with the default KPAR/NPAR settings.",
)
print(
    "\nOn average, using a 10x10x5 kpoints grid, calculations with KPAR=9, NPAR=sqrt(# of cores)",
    proportion_10x10x5,
    "the amount of time needed for calculations with the default KPAR/NPAR settings.",
)

On average, using a 4x4x2 kpoints grid, calculations with KPAR=9, NPAR=sqrt(# of cores) 0.3496038206680978 the amount of time needed for calculations with the default KPAR/NPAR settings.

On average, using a 10x10x5 kpoints grid, calculations with KPAR=9, NPAR=sqrt(# of cores) 0.5080902355201756 the amount of time needed for calculations with the default KPAR/NPAR settings.


fig = px.scatter(
    data_swift_1_K9_N4,
    x="Cores",
    y="scaled_rate",
    color="MPI",
    symbol="kpoints",
    hover_data=[
        "HPC System",
        "Partition",
        "Nodes",
        "cpu-bind",
        "MPI",
        "Benchmark Code",
    ],
    labels={"scaled_rate": "Rate(1/s)/Electronic Steps"},
    title="Benchmark 1 on Swift",
)
fig.show()


data_swift_1_K9_N4_4x4x2 = data_swift_1_K9_N4[data_swift_1_K9_N4["kpoints"] == "4x4x2"]
data_swift_1_K9_N4_10x10x5 = data_swift_1_K9_N4[
    data_swift_1_K9_N4["kpoints"] == "10x10x5"
]

proportion_4x4x2 = get_scaling(data_swift_1_K9_N4_4x4x2, "MPI", "intel_impi", "openmpi")
proportion_10x10x5 = get_scaling(
    data_swift_1_K9_N4_10x10x5, "MPI", "intel_impi", "openmpi"
)

print(
    "On average, using a 4x4x2 kpoints grid, calculations using Intel MPI ran in",
    proportion_4x4x2,
    "the amount of time as calculations using OpenMPI",
)
print(
    "\nOn average, using a 10x10x5 kpoints grid, calculations using Intel MPI ran in",
    proportion_10x10x5,
    "the amount of time as calculations using OpenMPI",
)

On average, using a 4x4x2 kpoints grid, calculations using Intel MPI ran in 0.8449282396277468 the amount of time as calculations using OpenMPI

On average, using a 10x10x5 kpoints grid, calculations using Intel MPI ran in 0.8581872496184438 the amount of time as calculations using OpenMPI


fig = px.scatter(
    data_swift_1_K9_N4,
    x="Cores",
    y="scaled_rate",
    color="cpu-bind",
    symbol="kpoints",
    hover_data=[
        "HPC System",
        "Partition",
        "Nodes",
        "cpu-bind",
        "MPI",
        "Benchmark Code",
    ],
    labels={"scaled_rate": "Rate(1/s)/Electronic Steps"},
    title="Benchmark 1 on Swift",
)
fig.show()


proportion_4x4x2_rank = get_scaling(
    data_swift_1_K9_N4_4x4x2, "cpu-bind", "rank", "none"
)
proportion_4x4x2_cores = get_scaling(
    data_swift_1_K9_N4_4x4x2, "cpu-bind", "cores", "none"
)
proportion_10x10x5_rank = get_scaling(
    data_swift_1_K9_N4_10x10x5, "cpu-bind", "rank", "none"
)
proportion_10x10x5_cores = get_scaling(
    data_swift_1_K9_N4_10x10x5, "cpu-bind", "cores", "none"
)

print(
    "On average, using a 4x4x2 kpoints grid, calculations on half-filled nodes with --cpu-bind=rank run in",
    proportion_4x4x2_rank,
    "the amount of time as calculations without --cpu-bind.",
)
print(
    "\nOn average, using a 4x4x2 kpoints grid, calculations on half-filled nodes with --cpu-bind=cores run in",
    proportion_4x4x2_cores,
    "the amount of time as calculations without --cpu-bind.",
)
print(
    "\nOn average, using a 10x10x5 kpoints grid, calculations on half-filled nodes with --cpu-bind=rank run in",
    proportion_10x10x5_rank,
    "the amount of time as calculations without --cpu-bind.",
)
print(
    "\nOn average, using a 10x10x5 kpoints grid, calculations on half-filled nodes with --cpu-bind=cores run in",
    proportion_10x10x5_cores,
    "the amount of time as calculations without --cpu-bind.",
)

On average, using a 4x4x2 kpoints grid, calculations on half-filled nodes with --cpu-bind=rank run in 1.0521222978842009 the amount of time as calculations without --cpu-bind.

On average, using a 4x4x2 kpoints grid, calculations on half-filled nodes with --cpu-bind=cores run in 1.0129159842027768 the amount of time as calculations without --cpu-bind.

On average, using a 10x10x5 kpoints grid, calculations on half-filled nodes with --cpu-bind=rank run in 1.092461620962752 the amount of time as calculations without --cpu-bind.

On average, using a 10x10x5 kpoints grid, calculations on half-filled nodes with --cpu-bind=cores run in 0.9975326120099117 the amount of time as calculations without --cpu-bind.


os.system("jupyter nbconvert --execute --to html VASP_Recommendations.ipynb")

30720

	Date	HPC System	Job ID	Partition	Benchmark Code	kpoints	math library	MPI	cpu-bind	Nodes	Cores	Nodelist	Energy	Electronic Steps	Runtime	KPAR	NPAR	node_fill
0	Thu Jan 6 09:22:57 MST 2022	Eagle	8144861	short	1	10x10x5	openmpi	openmpi	cores	1	36	r10i1n25	-6.03E+01	13	0:09:54	1	D	full
1	Thu Jan 6 09:12:43 MST 2022	Eagle	8144847	short	1	10x10x5	mkl	intel_impi	cores	1	36	r5i0n1	-6.03E+01	13	0:09:59	1	D	full
2	Thu Jan 6 09:35:59 MST 2022	Eagle	8144917	short	1	10x10x5	openmpi	openmpi	none	1	36	r10i0n16	-6.03E+01	13	0:09:54	1	D	full
3	Thu Jan 6 09:34:07 MST 2022	Eagle	8144903	short	1	10x10x5	mkl	intel_impi	none	1	36	r4i2n4	-6.03E+01	13	0:09:58	1	D	full
4	Thu Jan 6 09:29:02 MST 2022	Eagle	8144889	short	1	10x10x5	openmpi	openmpi	rank	1	36	r4i6n32	-6.03E+01	13	0:09:20	1	D	full
...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...
1567	Thu Jan 20 22:06:03 MST 2022	Eagle	8183166	short	1	10x10x5	openmpi	openmpi	none	1	9	r5i6n13	-6.03E+01	15	0:22:00	9	sqrt	partial
1568	Fri Dec 17 01:42:24 MST 2021	Eagle	8044011	short	2	1x1x1	mkl	intel_impi	cores	1	9	r6i2n5	-1.27E+03	36	4:53:27	1	D	partial
1569	Fri Dec 17 03:16:01 MST 2021	Eagle	8044013	short	2	1x1x1	mkl	intel_impi	none	1	9	r6i2n23	-1.27E+03	36	5:56:45	1	D	partial
1570	Fri Dec 17 03:12:33 MST 2021	Eagle	8044014	short	2	1x1x1	mkl	intel_impi	rank	1	9	r6i7n28	-1.27E+03	36	5:22:33	1	D	partial
1571	Fri Dec 3 22:47:06 UTC 2021	Vermillion	50004336	std	small	4x4x4	openmpi	openmpi	cores	1	8	vs-std-0003	-3.93E+01	18	0:00:04	1	D	partial

	Date	HPC System	Job ID	Partition	Benchmark Code	kpoints	math library	MPI	cpu-bind	Nodes	...	Energy	Electronic Steps	Runtime	KPAR	NPAR	node_fill	Runtime(s)	time_per_step	scaled_rate	Processor
0	Thu Jan 6 09:22:57 MST 2022	Eagle	8144861	short	1	10x10x5	openmpi	openmpi	cores	1	...	-6.03E+01	13	0:09:54	1	D	full	594.0	45.692308	0.021886	CPU
1	Thu Jan 6 09:12:43 MST 2022	Eagle	8144847	short	1	10x10x5	mkl	intel_impi	cores	1	...	-6.03E+01	13	0:09:59	1	D	full	599.0	46.076923	0.021703	CPU
2	Thu Jan 6 09:35:59 MST 2022	Eagle	8144917	short	1	10x10x5	openmpi	openmpi	none	1	...	-6.03E+01	13	0:09:54	1	D	full	594.0	45.692308	0.021886	CPU
3	Thu Jan 6 09:34:07 MST 2022	Eagle	8144903	short	1	10x10x5	mkl	intel_impi	none	1	...	-6.03E+01	13	0:09:58	1	D	full	598.0	46.000000	0.021739	CPU
4	Thu Jan 6 09:29:02 MST 2022	Eagle	8144889	short	1	10x10x5	openmpi	openmpi	rank	1	...	-6.03E+01	13	0:09:20	1	D	full	560.0	43.076923	0.023214	CPU
...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...
1567	Thu Jan 20 22:06:03 MST 2022	Eagle	8183166	short	1	10x10x5	openmpi	openmpi	none	1	...	-6.03E+01	15	0:22:00	9	sqrt	partial	1320.0	88.000000	0.011364	CPU
1568	Fri Dec 17 01:42:24 MST 2021	Eagle	8044011	short	2	1x1x1	mkl	intel_impi	cores	1	...	-1.27E+03	36	4:53:27	1	D	partial	17607.0	489.083333	0.002045	CPU
1569	Fri Dec 17 03:16:01 MST 2021	Eagle	8044013	short	2	1x1x1	mkl	intel_impi	none	1	...	-1.27E+03	36	5:56:45	1	D	partial	21405.0	594.583333	0.001682	CPU
1570	Fri Dec 17 03:12:33 MST 2021	Eagle	8044014	short	2	1x1x1	mkl	intel_impi	rank	1	...	-1.27E+03	36	5:22:33	1	D	partial	19353.0	537.583333	0.001860	CPU
1571	Fri Dec 3 22:47:06 UTC 2021	Vermillion	50004336	std	small	4x4x4	openmpi	openmpi	cores	1	...	-3.93E+01	18	0:00:04	1	D	partial	4.0	0.222222	4.500000	CPU

	Average 4x4x2 Runtime as a Percentage of 10x10x5 Runtime	Average Runtime as a Percentage of default KPAR/NPAR Configuration Runtime (4x4x2)	Average Runtime as a Percentage of default KPAR/NPAR Configuration Runtime (10x10x5)
KPAR=1,NPAR=4	21.59%	64.31%	71.27%
KPAR=1,NPAR=# of cores	20.15%	Default	Default
KPAR=1,NPAR=sqrt(# of cores)	26.15%	78.48%	69.92%
KPAR=4,NPAR=# of cores	26.28%	36.61%	40.97%
KPAR=9,NPAR=4	41.41%	70.91%	58.44%
KPAR=4,NPAR=sqrt(# of cores)	22.62%	35.38%	56.50%
KPAR=4,NPAR=4	23.83%	36.29%	42.71%
KPAR=9,NPAR=sqrt(# of cores)	27.51%	71.88%	59.42%
Average	26.19%

	Average 4x4x2 Runtime as a Percentage of 10x10x5 Runtime	Average Runtime as a Percentage of default KPAR/NPAR Configuration Runtime (4x4x2)	Average Runtime as a Percentage of default KPAR/NPAR Configuration Runtime (10x10x5)
KPAR=1,NPAR=4	19.75%	50.90%	60.28%
KPAR=1,NPAR=# of cores	18.76%	Default	Default
KPAR=1,NPAR=sqrt(# of cores)	18.56%	89.92%	89.36%
KPAR=4,NPAR=# of cores	20.46%	31.55%	35.68%
KPAR=9,NPAR=4	34.10%	37.86%	24.23%
KPAR=4,NPAR=sqrt(# of cores)	19.94%	37.25%	43.02%
KPAR=4,NPAR=4	20.70%	29.76%	33.77%
KPAR=9,NPAR=sqrt(# of cores)	31.93%	34.96%	50.81%
Average	23.03%

VASP Recommendations¶

Table of Contents :¶

Import necessary packages¶

Eagle¶

Recommendations for Running VASP on Eagle¶

Benchmark 2 on Eagle¶

Running on half filled nodes on Eagle¶

Running on GPUs on Eagle¶

MPI on Eagle with Benchmark 2¶

cpu-bind on Eagle with Benchmark 2¶

Benchmark 1 on Eagle¶

KPOINTS Scaling on Eagle¶

Changing KPAR and NPAR on Eagle¶

MPI on Eagle with Benchmark 1¶

cpu-bind on Eagle with Benchmark 1¶

Running VASP On Swift¶

Recommendations for Running VASP on Swift¶

Benchmark 2 on Swift¶

Running on half filled nodes on Swift¶

MPI on Swift with Benchmark 2¶

cpu-bind on Swift with Benchmark 2¶

Benchmark 1 on Swift¶

KPOINTS Scaling on Swift¶

Changing KPAR and NPAR on Swift¶

MPI on Swift with Benchmark 1¶

cpu-bind on Swift with Benchmark 1¶